package com.shenfa.service;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;

import com.shenfa.bean.PaperCityCrd;
import com.shenfa.bean.TreeNode;
import com.shenfa.bean.ProductInfType;
import com.shenfa.bean.TreeNodeCheck;
import com.shenfa.dao.ProductDao;

public class ProductService {
	// 日志
	private static final Logger log = Logger.getLogger(ProductService.class);

	@Autowired
	private ProductDao Productdao;
	@Autowired
	private CityService cityService;
	

	/**
	 * 类型表所有数据,用于生成树根节点,类型下拉框选项
	 * 
	 * @author 龙辰三
	 * @date 2011-8-22
	 * @return treeJSONObj
	 */
	public List<TreeNode> doTreeRoot(ProductInfType product) {
		return Productdao.queryTreeRoot(product);
	}
	
	/**
	 * 查询产品类型表gridpanel显示列
	 * 
	 * @param 龙辰三
	 * @date 2011-8-20
	 * @param prodId
	 * 
	 * @return List<ProductInfType>
	 */
	@SuppressWarnings("unchecked")
	public List<ProductInfType> queryProdsType(ProductInfType prodinfo,int start,int limit) {
		return Productdao.queryProdsType(prodinfo,start,limit);
	}
	
	/**
	 * 产品类型总条数
	 * 
	 * @param prodinfo
	 * @return
	 */
	public int TotalRulePage(ProductInfType prodinfo){
		return Productdao.TotalRulePage(prodinfo);
	}
	/**
	 * 查询卡产品的名称下拉框选项
	 * @return
	 */
	public List<ProductInfType> doProdNameList() {
		return Productdao.queryProdName();
	}

	/**
	 * 根据选中的树节点,异步生成下层子节点
	 * 
	 * @author 龙辰三
	 * @date 2011-8-22
	 * 
	 * @param product
	 *            [选中的节点]
	 * @return treeJSONObj
	 */

	public List<TreeNode> doTreeMenu(TreeNode node) {
		return Productdao.queryTreeMenu(node);
	}

	/**
	 * 根据选中的树节点,分页参数.生成gridpanel显示的json数据
	 * 
	 * @author 龙辰三
	 * @date 2011-8-22
	 * 
	 * @param product
	 *            [选中的节点]
	 * @param skipResults
	 *            [起始条数]
	 * @param maxResults
	 *            [显示数据长度]
	 * @return treeJSONObj
	 */
	public List<ProductInfType> doGridList(ProductInfType product,
			int skipResults, int maxResults) {
		return Productdao.queryProdGrid(product, skipResults, maxResults);
	}
	
	/**
	 * 查询总记录数
	 * 
	 * @param product
	 * @return
	 */
	public int  queryCount(ProductInfType product) {
		return Productdao.queryCount(product);
	}
	
	
	/**
	 * 查询卡类型是否有对应的产品,如果有则禁止删除
	 * 
	 * @param product
	 * @return
	 */
	public int  queryProdForType(String typeid) {
		return Productdao.queryProdForType(typeid);
	}
	
	/**
	 * 查询产品城市菜单树
	 * 
	 * @return
	 */
	public List<TreeNodeCheck> doLsitByCardid(String node, String cardid) {
		// 取城市id生成map
		Map<String, String> map = new HashMap<String, String>();
		// 根据产品id查询对应的城市编号
		if (null != cardid || !"".equals(cardid)) {
			List<String> cradlist = Productdao.queryCardCity(cardid);
			for (String s : cradlist) {
				map.put(s, s);
			}
		}
		// 查询一级城市树节点
		List<TreeNode> citylist = cityService.queryTree("0");
		
		// 返回的树集合
		List<TreeNodeCheck> cityCheckList = new ArrayList<TreeNodeCheck>();
		//	构造选择树节点node
		TreeNodeCheck tnc;
		//	构造树节点id
		String funcid = "";
		// 购置返回树
		for (TreeNode c : citylist) {
			tnc = new TreeNodeCheck();
			funcid = c.getId();
			tnc.setId(funcid);// 设置树节点id
			tnc.setText(c.getText());// 设置树节点text
			tnc.setLeaf(!c.isLeaf());//是否有子节点
			// 匹配卡产品id对应的城市节点
			if (map.containsKey(funcid)) {
				//有匹配,设置为选择
				tnc.setChecked(true);
				//匹配后从map中移除
				map.remove(funcid);
			}
			List<TreeNodeCheck> cityCheckList1 = new ArrayList<TreeNodeCheck>();
			TreeNodeCheck tnc1;
			// 查询二级城市树节点
			List<TreeNode> childlist = cityService.queryTree(c.getId());
			for (TreeNode n : childlist) {
				tnc1 = new TreeNodeCheck();
				funcid = n.getId();
				tnc1.setId(funcid);// 设置树节点id
				tnc1.setText(n.getText());// 设置树节点text
				tnc1.setLeaf(!n.isLeaf());//是否有子节点
				// 匹配卡产品id对应的城市节点
				if (map.containsKey(funcid)) {
					//有匹配,设置为选择
					tnc1.setChecked(true);
					//匹配后从map中移除
					map.remove(funcid);
				}
				cityCheckList1.add(tnc1);
			}
			tnc.setChildren(cityCheckList1);//设置子节点list
			cityCheckList.add(tnc);
		}
		// 获取要返回的树

		return cityCheckList;
	}

	/**
	 * 新增卡产品信息
	 * 
	 * @param product
	 * @return
	 */
	public boolean addProdInfo(ProductInfType product, String idlist) {
		// **************************新增产品数据******************
		if (null == product || null == product.getProdId() || "".equals(product.getProdId())) {
			return false;
		}
		product.setProdState("1");
		// 根据类型name查询类型id
		//List<TreeNode> list = Productdao.queryTreeRoot(product);
		//for (TreeNode res : list) {
		//	product.setProdTypeId(res.getId());
		//}

		// 新增默认没有子 节点
		product.setProdFlag("0");
		// 新增产品信息数据
		Productdao.addProdInfo(product);
		
		// ************************新增城市关联表信息**********************
		// 拆分页面传的城市id集合字符串
		String[] cityid;
		if (null != idlist && !"".equals(idlist)) {
			cityid = idlist.split("\\|");
			PaperCityCrd cardcty = new PaperCityCrd();
			// 传序列号id
			cardcty.setCard_no(product.getProdId());
			for (String s : cityid) {
				cardcty.setCity_no(s);
				Productdao.addCardCity(cardcty);
			}
		}
		// ********************设置父亲节点节点标识为1**************
		// 构造父亲节点查询条件
		product.setProdId(product.getProdParId());
		product.setProdParId(null);
		// 查询父亲节点信息，
		List<ProductInfType> prodpr = Productdao.queryProdGrid(product, 0, 1);
		if (null == prodpr) {
			return false;
		}
		for (ProductInfType res : prodpr) {
			// 设置其ProdFlag标识为(1:有子节点)
			res.setProdFlag("1");
			// 修改父节点的子节点标识
			Productdao.editProdInfo(res);
		}

		return true;
	}

	/**
	 * 修改卡产品信息
	 * 
	 * @param product
	 * @return
	 */
	public boolean editProdInfo(ProductInfType product, String idlist) {
		if (null == product.getProdId() || "".equals(product.getProdId())) {
			return false;
		}
		Productdao.editProdInfo(product);

		// ************************新增城市关联表信息**********************
		// 查询已有的城市关联
		List<String> oldlist = Productdao.queryCardCity(product.getProdId());

		if (null != idlist) {
			// 拆分页面传的城市id集合字符串
			String[] cityid = idlist.split("\\|");

			// 接收未匹配的cityid
			List<String> newlist = new ArrayList<String>();
			// 构造新增数据
			PaperCityCrd cardcty = new PaperCityCrd();
			// 传序列号id
			cardcty.setCard_no(product.getProdId());

			/*
			 * 匹配oldcard、newcard城市id。可以匹配的说明未作修改可以不用操作, oldlist中未匹配的是需要删除的
			 * newlist中未匹配的是需要新增的
			 */
			for (String s : cityid) {
				if (oldlist.contains(s)) {
					oldlist.remove(s);
				} else {
					newlist.add(s);
				}
			}
			// 删除未匹配原cityid
			for (String o : oldlist) {
				cardcty.setCity_no(o);
				Productdao.deleteCardCity(cardcty);
			}
			// 新增未匹配新cityid
			for (String n : newlist) {
				if (!"".equals(n)) {
					cardcty.setCity_no(n);
					Productdao.addCardCity(cardcty);
				}
			}
		}
		return true;
	}

	/**
	 * 删除卡产品信息
	 * 
	 * @param product
	 * @return
	 */
	public boolean deleteProdInfo(ProductInfType product) {
		Productdao.deleteProdInfo(product);
		product.setProdId(null);
		int pro = Productdao.queryCount(product);
		if(pro==0){
			product.setProdId(product.getProdParId());
			product.setProdFlag("0");
			product.setProdParId(null);
			Productdao.editDelProd(product);
		}
		
		//软删,不删除城市
//		// 构造删除条件
//		PaperCityCrd cardcty = new PaperCityCrd();
//		// 传序列号id
//		cardcty.setCard_no(product.getProdId());
//		// 删除卡产品对应的城市
//		Productdao.deleteCardCity(cardcty);
		return true;
	}

	/**
	 * 新增卡类型信息
	 * 
	 * @param product
	 * @return
	 */
	public boolean addProdType(ProductInfType product) {
		if (null == product.getProdTypeId()
				|| "".equals(product.getProdTypeId())) {
			return false;
		}
		ProductInfType type = Productdao.queryType(product);
		//
		if(null!=type&&"0".equals(type.getProdTypeSate())){
			product.setProdTypeSate("1");
			Productdao.editProdType(product);
		}else{
			Productdao.addProdType(product);
		}
		return true;
	}

	/**
	 * 查询当前新增id是否存在
	 * 
	 * @param product
	 * @return
	 */
	public ProductInfType queryIdYON(ProductInfType product){		
		return Productdao.queryType(product);
	}
	
	/**
	 * 修改卡类型信息
	 * 
	 * @param product
	 * @return
	 */
	public boolean editProdType(ProductInfType product) {
		if (null == product.getProdTypeId()
				|| "".equals(product.getProdTypeId())) {
			return false;
		}

		Productdao.editProdType(product);
		return true;
	}

	/**
	 * 删除卡类型信息
	 * 
	 * @param product
	 * @return
	 */
	public boolean deleteProdType(ProductInfType product) {
		Productdao.deleteProdType(product);
		return true;
	}

	/**
	 * 根据卡产品id查询城市id
	 * 
	 * @param cardid
	 * @return
	 */
	public List<String> queryCardCity(String cardid) {
		return Productdao.queryCardCity(cardid);
	}

	/**
	 * 添加卡产品城市关联表
	 * 
	 * @param pardcty
	 * @return
	 */
	public boolean addCardCity(PaperCityCrd pardcty) {
		Productdao.addCardCity(pardcty);
		return true;
	}

}
